import { ref, reactive, onMounted } from 'vue'
import { message } from 'ant-design-vue'
import type { TablePaginationConfig } from 'ant-design-vue'
import { getFileList, deleteFiles, downloadFile } from '@/api/file'
import type { File as FileData, FileQuery } from '@/types/api/file'
import type { Dayjs } from 'dayjs'

/**
 * 文件管理钩子函数
 */
export default function useFileManagement() {
  // ------------ 国际化和工具引入 ------------
  const { t } = useI18n()

  // ------------ 加载状态 ------------
  const loading = ref(false)
  const loadError = ref(false)
  const errorMessage = ref('')

  // ------------ 数据列表 ------------
  const fileList = ref<FileData[]>([])

  // ------------ 选中状态 ------------
  const selectedRowKeys = ref<string[]>([])

  // ------------ 日期范围 ------------
  const dateRange = ref<[Dayjs, Dayjs] | null>(null)

  // ------------ 预览相关 ------------
  const previewVisible = ref(false)
  const previewFile = ref<FileData | null>(null)

  // ------------ 查询参数 ------------
  const queryParams = reactive<FileQuery>({
    keyword: '',
    fileType: undefined,
    page: 1,
    pageSize: 10
  })

  // ------------ 分页配置 ------------
  const pagination = reactive<TablePaginationConfig>({
    current: 1,
    pageSize: 10,
    total: 0,
    showSizeChanger: true,
    showQuickJumper: true,
    showTotal: (total) => t('common.totalItems', { total })
  })

  // 文件上传相关配置
  const maxSize = ref(10) // 默认最大文件大小（MB）
  const allowedTypes = ref('*') // 默认允许所有文件类型

  // 通过文件名获取文件类型
  const getFileTypeByName = (fileName: string): string => {
    const ext = fileName.split('.').pop()?.toLowerCase() || ''
    const typeMap: Record<string, string> = {
      jpg: 'image/jpeg',
      jpeg: 'image/jpeg',
      png: 'image/png',
      gif: 'image/gif',
      pdf: 'application/pdf',
      doc: 'application/msword',
      docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
      xls: 'application/vnd.ms-excel',
      xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
      ppt: 'application/vnd.ms-powerpoint',
      pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
      txt: 'text/plain',
      mp4: 'video/mp4',
      mp3: 'audio/mpeg'
    }
    
    return typeMap[ext] || 'application/octet-stream'
  }

  // ------------ 表格交互方法 ------------
  /**
   * 表格行选择变更
   * @param keys 选中的行的键值
   */
  const onSelectChange = (keys: string[]) => {
    selectedRowKeys.value = keys
  }

  /**
   * 切换行选择状态（卡片视图使用）
   * @param id 文件ID
   */
  const toggleSelection = (id: string) => {
    const index = selectedRowKeys.value.indexOf(id)
    if (index > -1) {
      selectedRowKeys.value.splice(index, 1)
    } else {
      selectedRowKeys.value.push(id)
    }
  }

  /**
   * 表格分页、排序、筛选变化事件
   * @param pag 分页参数
   */
  const handleTableChange = (pag: TablePaginationConfig) => {
    pagination.current = pag.current || 1
    pagination.pageSize = pag.pageSize || 10
    fetchFileList()
  }

  // ------------ 搜索区域方法 ------------
  /**
   * 搜索处理
   */
  const handleSearch = () => {
    pagination.current = 1
    fetchFileList()
  }

  /**
   * 重置搜索条件
   */
  const resetQuery = () => {
    queryParams.keyword = ''
    queryParams.fileType = undefined
    dateRange.value = null
    pagination.current = 1
    fetchFileList()
  }

  // ------------ 数据操作方法 ------------
  /**
   * 获取文件列表
   */
  const fetchFileList = async () => {
    loading.value = true
    loadError.value = false
    errorMessage.value = ''
    
    try {
      // 处理日期范围
      const params = { ...queryParams }
      params.page = pagination.current || 1
      params.pageSize = pagination.pageSize || 10
      
      if (dateRange.value && dateRange.value.length === 2) {
        params.dateRange = [
          dateRange.value[0].format('YYYY-MM-DD'),
          dateRange.value[1].format('YYYY-MM-DD')
        ]
      }
      
      const res = await getFileList(params)
      if (res.success) {
        fileList.value = res.data.list
        pagination.total = res.data.total
        
        // 处理空数据情况
        if (fileList.value.length === 0 && pagination.total > 0) {
          // 如果当前页没有数据但总数大于0，回到第一页
          pagination.current = 1
          await fetchFileList()
        }
      } else {
        loadError.value = true
        errorMessage.value = res.message || t('file.loadFailed')
        message.error(res.message || t('file.loadFailed'))
      }
    } catch (error: any) {
      loadError.value = true
      errorMessage.value = error?.message || t('file.loadFailed')
      message.error(t('file.loadFailed'))
    } finally {
      loading.value = false
    }
  }

  /**
   * 上传前检查
   * @param file 要上传的文件
   */
  const beforeUpload = async (file: File, fileList: File[]): Promise<void> => {
    // 检查文件大小
    const isLimitSize = file.size / 1024 / 1024 < maxSize.value
    if (!isLimitSize) {
      message.error(t('file.sizeLimit', { size: maxSize.value }))
      return
    }
    
    // 检查文件类型
    if (allowedTypes.value && allowedTypes.value !== '*') {
      const acceptTypes = allowedTypes.value.split(',')
      const fileType = file.type || getFileTypeByName(file.name)
      const isAcceptType = acceptTypes.some((type: string) => {
        if (type.startsWith('.')) {
          // 检查后缀
          return file.name.toLowerCase().endsWith(type.toLowerCase())
        } else {
          // 检查MIME类型
          return fileType.includes(type.trim())
        }
      })
      
      if (!isAcceptType) {
        message.error(t('file.typeNotAccepted'))
        return
      }
    }
  }

  /**
   * 删除文件
   * @param file 文件信息
   */
  const handleDelete = async (file: FileData) => {
    try {
      const res = await deleteFiles([file.id])
      if (res.success) {
        message.success(t('file.deleteSuccess'))
        // 如果当前页删除后没有数据了，且不是第一页，则跳转到前一页
        if (pagination.current && pagination.current > 1 && fileList.value.length === 1) {
          pagination.current -= 1
        }
        fetchFileList()
      } else {
        message.error(res.message || t('file.deleteFailed'))
      }
    } catch (error) {
      message.error(t('file.deleteFailed'))
    }
  }

  /**
   * 批量删除文件
   */
  const handleBatchDelete = async () => {
    if (selectedRowKeys.value.length === 0) {
      message.warning(t('common.noSelection'))
      return
    }
    
    try {
      const res = await deleteFiles(selectedRowKeys.value as string[])
      if (res.success) {
        message.success(t('file.batchDeleteSuccess'))
        selectedRowKeys.value = []
        // 如果当前页删除后没有数据了，且不是第一页，则跳转到前一页
        if (pagination.current && pagination.current > 1 && 
            fileList.value.length <= selectedRowKeys.value.length) {
          pagination.current -= 1
        }
        fetchFileList()
      } else {
        message.error(res.message || t('file.batchDeleteFailed'))
      }
    } catch (error) {
      message.error(t('file.batchDeleteFailed'))
    }
  }

  /**
   * 下载文件
   * @param file 文件信息
   */
  const handleDownload = async (file: FileData) => {
    try {
      const res = await downloadFile(file.id)
      // 创建下载链接
      const blob = new Blob([res])
      const url = window.URL.createObjectURL(blob)
      const link = document.createElement('a')
      link.href = url
      link.download = file.originalName
      link.click()
      window.URL.revokeObjectURL(url)
    } catch (error) {
      message.error(t('file.downloadFailed'))
    }
  }

  /**
   * 复制文件链接
   * @param file 文件信息
   */
  const handleCopyLink = (file: FileData) => {
    try {
      navigator.clipboard.writeText(file.url)
      message.success(t('file.copyLinkSuccess'))
    } catch (error) {
      message.error(t('file.copyLinkFailed'))
    }
  }

  // ------------ 预览操作方法 ------------
  /**
   * 预览文件
   * @param file 文件信息
   */
  const handlePreview = (file: FileData) => {
    previewFile.value = file
    previewVisible.value = true
  }

  /**
   * 关闭预览
   */
  const handlePreviewCancel = () => {
    previewVisible.value = false
    previewFile.value = null
  }

  // ------------ 文件类型检测方法 ------------
  /**
   * 判断是否为图片文件
   * @param file 文件信息
   */
  const isImageFile = (file: FileData): boolean => {
    return file.type.startsWith('image/') || 
      /\.(jpg|jpeg|png|gif|bmp|webp|svg)$/i.test(file.extension || '')
  }

  /**
   * 判断是否为文档文件
   * @param file 文件信息
   */
  const isDocumentFile = (file: FileData): boolean => {
    return /\.(pdf|doc|docx|xls|xlsx|ppt|pptx|txt)$/i.test(file.extension || '')
  }

  /**
   * 判断是否为PDF文件
   * @param file 文件信息
   */
  const isPdfFile = (file: FileData): boolean => {
    return file.type === 'application/pdf' || (file.extension || '').toLowerCase() === 'pdf'
  }

  /**
   * 判断是否为视频文件
   * @param file 文件信息
   */
  const isVideoFile = (file: FileData): boolean => {
    return file.type.startsWith('video/') || 
      /\.(mp4|webm|ogg|mov|avi)$/i.test(file.extension || '')
  }

  /**
   * 判断是否为音频文件
   * @param file 文件信息
   */
  const isAudioFile = (file: FileData): boolean => {
    return file.type.startsWith('audio/') || 
      /\.(mp3|wav|ogg|aac)$/i.test(file.extension || '')
  }

  /**
   * 判断文件是否可预览
   * @param file 文件信息
   */
  const isPreviewable = (file: FileData): boolean => {
    return isImageFile(file) || isPdfFile(file) || isVideoFile(file) || isAudioFile(file)
  }

  // ------------ 辅助方法 ------------
  /**
   * 格式化文件大小
   * @param size 文件大小（字节）
   */
  const formatFileSize = (size: number): string => {
    const units = ['B', 'KB', 'MB', 'GB', 'TB']
    let index = 0
    let fileSize = size
    
    while (fileSize >= 1024 && index < units.length - 1) {
      fileSize /= 1024
      index++
    }
    
    return `${fileSize.toFixed(2)} ${units[index]}`
  }

  /**
   * 日期格式化
   * @param date 日期字符串
   */
  const formatDate = (date: string) => {
    return date ? new Date(date).toLocaleString() : ''
  }

  // ------------ 初始化 ------------
  onMounted(() => {
    fetchFileList()
  })

  return {
    // ------------ 状态 ------------
    loading,
    loadError,
    errorMessage,
    fileList,
    selectedRowKeys,
    dateRange,
    previewVisible,
    previewFile,
    queryParams,
    pagination,

    // ------------ 表格交互方法 ------------
    onSelectChange,
    toggleSelection,
    handleTableChange,

    // ------------ 搜索区域方法 ------------
    handleSearch,
    resetQuery,

    // ------------ 数据操作方法 ------------
    fetchFileList,
    beforeUpload,
    handleDelete,
    handleBatchDelete,
    handleDownload,
    handleCopyLink,

    // ------------ 预览操作方法 ------------
    handlePreview,
    handlePreviewCancel,

    // ------------ 文件类型检测方法 ------------
    isImageFile,
    isDocumentFile,
    isPdfFile,
    isVideoFile,
    isAudioFile,
    isPreviewable,

    // ------------ 辅助方法 ------------
    formatFileSize,
    formatDate
  }
} 